home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / misc / gnuplot-3.7src.lha / gnuplot-3.7src / gnuplot-3.7.lha / gnuplot-3.7 / show.c < prev    next >
C/C++ Source or Header  |  1998-12-16  |  47KB  |  1,738 lines
  1. #ifndef lint
  2. static char *RCSid = "$Id: show.c,v 1.50 1998/06/18 14:55:18 ddenholm Exp $";
  3. #endif
  4.  
  5. /* GNUPLOT - show.c */
  6.  
  7. /*[
  8.  * Copyright 1986 - 1993, 1998   Thomas Williams, Colin Kelley
  9.  *
  10.  * Permission to use, copy, and distribute this software and its
  11.  * documentation for any purpose with or without fee is hereby granted,
  12.  * provided that the above copyright notice appear in all copies and
  13.  * that both that copyright notice and this permission notice appear
  14.  * in supporting documentation.
  15.  *
  16.  * Permission to modify the software is granted, but not the right to
  17.  * distribute the complete modified source code.  Modifications are to
  18.  * be distributed as patches to the released version.  Permission to
  19.  * distribute binaries produced by compiling modified sources is granted,
  20.  * provided you
  21.  *   1. distribute the corresponding source modifications from the
  22.  *    released version in the form of a patch file along with the binaries,
  23.  *   2. add special version identification to distinguish your version
  24.  *    in addition to the base release version number,
  25.  *   3. provide your name and address as the primary contact for the
  26.  *    support of your modified version, and
  27.  *   4. retain our contact information in regard to use of the base
  28.  *    software.
  29.  * Permission to distribute the released version of the source code along
  30.  * with corresponding source modifications in the form of a patch file is
  31.  * granted with same provisions 2 through 4 for binary distributions.
  32.  *
  33.  * This software is provided "as is" without express or implied warranty
  34.  * to the extent permitted by applicable law.
  35. ]*/
  36.  
  37.  
  38. /*
  39.  * 19 September 1992  Lawrence Crowl  (crowl@cs.orst.edu)
  40.  * Added user-specified bases for log scaling.
  41.  */
  42.  
  43.  
  44. #include "plot.h"
  45. #include "setshow.h"
  46.  
  47. #define DEF_FORMAT   "%g"    /* default format for tic mark labels */
  48. #define SIGNIF (0.01)        /* less than one hundredth of a tic mark */
  49.  
  50.  
  51. /* input data, parsing variables */
  52.  
  53. extern TBOOLEAN is_3d_plot;
  54.  
  55. /* From version.c, used in show_version () */
  56. extern char version[];
  57. extern char patchlevel[];
  58. extern char date[];
  59. extern char gnuplot_copyright[];
  60. extern char faq_location[];
  61. extern char bug_email[];
  62. extern char help_email[];
  63.  
  64.  
  65. #ifndef TIMEFMT
  66. #define TIMEFMT "%d/%m/%y,%H:%M"
  67. #endif
  68. /* format for date/time for reading time in datafile */
  69.  
  70.  
  71.  
  72. /******** Local functions ********/
  73.  
  74. static void show_style __PROTO((char name[], enum PLOT_STYLE style));
  75. static void show_range __PROTO((int axis, double min, double max, int autosc, char *text));
  76. static void show_zero __PROTO((void));
  77. static void show_border __PROTO((void));
  78. static void show_dgrid3d __PROTO((void));
  79. static void show_offsets __PROTO((void));
  80. static void show_samples __PROTO((void));
  81. static void show_isosamples __PROTO((void));
  82. static void show_output __PROTO((void));
  83. static void show_view __PROTO((void));
  84. static void show_size __PROTO((void));
  85. static void show_origin __PROTO((void));
  86. static void show_title __PROTO((void));
  87. static void show_xyzlabel __PROTO((char *name, label_struct * label));
  88. static void show_angles __PROTO((void));
  89. static void show_boxwidth __PROTO((void));
  90. static void show_bars __PROTO((void));
  91. static void show_xzeroaxis __PROTO((void));
  92. static void show_yzeroaxis __PROTO((void));
  93. static void show_label __PROTO((int tag));
  94. static void show_linestyle __PROTO((int tag));
  95. static void show_arrow __PROTO((int tag));
  96. static void show_grid __PROTO((void));
  97. static void show_key __PROTO((void));
  98. static void show_keytitle __PROTO((void));
  99. static void show_mtics __PROTO((int mini, double freq, char *name));
  100. static void show_pointsize __PROTO((void));
  101. static void show_encoding __PROTO((void));
  102. static void show_polar __PROTO((void));
  103. static void show_parametric __PROTO((void));
  104. static void show_tics __PROTO((int showx, int showy, int showz, int showx2, int showy2));
  105. static void show_ticdef __PROTO((int tics, int axis, struct ticdef * tdef, char *text, int rotate_tics, char *ticfmt));
  106. static void show_term __PROTO((void));
  107. static void show_plot __PROTO((void));
  108. static void show_autoscale __PROTO((void));
  109. static void show_clip __PROTO((void));
  110. static void show_contour __PROTO((void));
  111. static void show_mapping __PROTO((void));
  112. static void show_format __PROTO((void));
  113. static void show_logscale __PROTO((void));
  114. static void show_variables __PROTO((void));
  115. static void show_surface __PROTO((void));
  116. static void show_hidden3d __PROTO((void));
  117. static void show_label_contours __PROTO((void));
  118. static void show_margin __PROTO((void));
  119. static void show_position __PROTO((struct position * pos));
  120.  
  121. static TBOOLEAN show_one __PROTO((void));
  122. static TBOOLEAN show_two __PROTO((void));
  123. static void show_timefmt __PROTO((void));
  124. static void show_locale __PROTO((void));
  125. static void show_missing __PROTO((void));
  126. static void show_datatype __PROTO((char *name, int axis));
  127. static void show_locale __PROTO((void));
  128.  
  129. /* following code segment appears over and over again */
  130.  
  131. #define SHOW_NUM_OR_TIME(x, axis) \
  132. do{if (datatype[axis]==TIME) { \
  133.   char s[80]; char *p; \
  134.   putc('"', stderr);   \
  135.   gstrftime(s,80,timefmt,(double)(x)); \
  136.   for(p=s; *p; ++p) {\
  137.    if ( *p == '\t' ) fputs("\\t",stderr);\
  138.    else if (*p == '\n') fputs("\\n",stderr); \
  139.    else if ( *p > 126 || *p < 32 ) fprintf(stderr,"\\%03o",*p);\
  140.    else putc(*p, stderr);\
  141.   }\
  142.   putc('"', stderr);\
  143.  } else {\
  144.   fprintf(stderr,"%g",x);\
  145. }} while(0)
  146.  
  147.  
  148. /******* The 'show' command *******/
  149. void show_command()
  150. {
  151.     /* show at is undocumented/hidden... */
  152.     static char GPFAR showmess[] =
  153.     "valid set options:  [] = choose one, {} means optional\n\n\
  154. \t'all',  'angles',  'arrow',  'autoscale',  'bar', 'border',  'boxwidth',\n\
  155. \t'clip', 'cntrparam', 'contour',  'data',  'dgrid3d',  'dummy',\n\
  156. \t'encoding', 'format', 'function',  'grid',  'hidden',  'isosamples',\n\
  157. \t'key', 'label', 'linestyle', 'locale', 'logscale', 'mapping', 'margin',\n\
  158. \t'missing', 'offsets', 'origin', 'output', 'plot', 'parametric',\n\
  159. \t'pointsize', 'polar', '[rtuv]range', 'samples', 'size', 'terminal',\n\
  160. \t'tics', 'timestamp', 'timefmt', 'title', 'variables', 'version',\n\
  161. \t'view',   '[xyz]{2}label',   '[xyz]{2}range',   '{m}[xyz]{2}tics',\n\
  162. \t'[xyz]{2}[md]tics',   '[xyz]{2}zeroaxis',   '[xyz]data',   'zero',\n\
  163. \t'zeroaxis'";
  164.  
  165.  
  166.     c_token++;
  167.  
  168.     if (!show_one() && !show_two())
  169.     int_error(showmess, c_token);
  170.     screen_ok = FALSE;
  171.     (void) putc('\n', stderr);
  172. }
  173.  
  174. /* return TRUE if a command match, FALSE if not */
  175. static TBOOLEAN
  176.  show_one()
  177. {
  178.     if (almost_equals(c_token, "ac$tion_table") ||
  179.     equals(c_token, "at")) {
  180.     c_token++;
  181.     show_at();
  182.     c_token++;
  183.     } else if (almost_equals(c_token, "ar$row")) {
  184.     struct value a;
  185.     int tag = 0;
  186.  
  187.     c_token++;
  188.     if (!END_OF_COMMAND) {
  189.         tag = (int) real(const_express(&a));
  190.         if (tag <= 0)
  191.         int_error("tag must be > zero", c_token);
  192.     }
  193.     (void) putc('\n', stderr);
  194.     show_arrow(tag);
  195.     } else if (almost_equals(c_token, "au$toscale")) {
  196.     (void) putc('\n', stderr);
  197.     show_autoscale();
  198.     c_token++;
  199.     } else if (almost_equals(c_token, "b$ars")) {
  200.     (void) putc('\n', stderr);
  201.     show_bars();
  202.     c_token++;
  203.     } else if (almost_equals(c_token, "bor$der")) {
  204.     (void) putc('\n', stderr);
  205.     show_border();
  206.     c_token++;
  207.     } else if (almost_equals(c_token, "box$width")) {
  208.     (void) putc('\n', stderr);
  209.     show_boxwidth();
  210.     c_token++;
  211.     } else if (almost_equals(c_token, "c$lip")) {
  212.     (void) putc('\n', stderr);
  213.     show_clip();
  214.     c_token++;
  215.     } else if (almost_equals(c_token, "ma$pping")) {
  216.     (void) putc('\n', stderr);
  217.     show_mapping();
  218.     c_token++;
  219.     } else if (almost_equals(c_token, "co$ntour") ||
  220.            almost_equals(c_token, "cn$trparam")) {
  221.     (void) putc('\n', stderr);
  222.     show_contour();
  223.     c_token++;
  224.     } else if (almost_equals(c_token, "da$ta")) {
  225.     c_token++;
  226.     if (!almost_equals(c_token, "s$tyle"))
  227.         int_error("expecting keyword 'style'", c_token);
  228.     (void) putc('\n', stderr);
  229.     show_style("data", data_style);
  230.     c_token++;
  231.     } else if (almost_equals(c_token, "dg$rid3d")) {
  232.     (void) putc('\n', stderr);
  233.     show_dgrid3d();
  234.     c_token++;
  235.     } else if (almost_equals(c_token, "du$mmy")) {
  236.     (void) fprintf(stderr, "\n\tdummy variables are \"%s\" and \"%s\"\n",
  237.                dummy_var[0], dummy_var[1]);
  238.     c_token++;
  239.     } else if (almost_equals(c_token, "fo$rmat")) {
  240.     show_format();
  241.     c_token++;
  242.     } else if (almost_equals(c_token, "fu$nctions")) {
  243.     c_token++;
  244.     if (almost_equals(c_token, "s$tyle")) {
  245.         (void) putc('\n', stderr);
  246.         show_style("functions", func_style);
  247.         c_token++;
  248.     } else
  249.         show_functions();
  250.     } else if (almost_equals(c_token, "lo$gscale")) {
  251.     (void) putc('\n', stderr);
  252.     show_logscale();
  253.     c_token++;
  254.     } else if (almost_equals(c_token, "of$fsets")) {
  255.     (void) putc('\n', stderr);
  256.     show_offsets();
  257.     c_token++;
  258.     } else if (almost_equals(c_token, "ma$rgin")) {
  259.     (void) putc('\n', stderr);
  260.     show_margin();
  261.     c_token++;
  262.     } else if (almost_equals(c_token, "o$utput")) {
  263.     (void) putc('\n', stderr);
  264.     show_output();
  265.     c_token++;
  266.     } else if (almost_equals(c_token, "tit$le")) {
  267.     (void) putc('\n', stderr);
  268.     show_xyzlabel("title", &title);
  269.     c_token++;
  270.     } else if (almost_equals(c_token, "mis$sing")) {
  271.     (void) putc('\n', stderr);
  272.     show_missing();
  273.     c_token++;
  274.     } else if (almost_equals(c_token, "xl$abel")) {
  275.     (void) putc('\n', stderr);
  276.     show_xyzlabel("xlabel", &xlabel);
  277.     c_token++;
  278.     } else if (almost_equals(c_token, "x2l$abel")) {
  279.     (void) putc('\n', stderr);
  280.     show_xyzlabel("x2label", &x2label);
  281.     c_token++;
  282.     } else if (almost_equals(c_token, "yl$abel")) {
  283.     (void) putc('\n', stderr);
  284.     show_xyzlabel("ylabel", &ylabel);
  285.     c_token++;
  286.     } else if (almost_equals(c_token, "y2l$abel")) {
  287.     (void) putc('\n', stderr);
  288.     show_xyzlabel("y2label", &y2label);
  289.     c_token++;
  290.     } else if (almost_equals(c_token, "zl$abel")) {
  291.     (void) putc('\n', stderr);
  292.     show_xyzlabel("zlabel", &zlabel);
  293.     c_token++;
  294.     } else if (almost_equals(c_token, "keyt$itle")) {
  295.     (void) putc('\n', stderr);
  296.     show_keytitle();
  297.     c_token++;
  298.     } else if (almost_equals(c_token, "xda$ta")) {
  299.     (void) putc('\n', stderr);
  300.     show_datatype("xdata", FIRST_X_AXIS);
  301.     c_token++;
  302.     } else if (almost_equals(c_token, "yda$ta")) {
  303.     (void) putc('\n', stderr);
  304.     show_datatype("ydata", FIRST_Y_AXIS);
  305.     c_token++;
  306.     } else if (almost_equals(c_token, "x2da$ta")) {
  307.     (void) putc('\n', stderr);
  308.     show_datatype("x2data", SECOND_X_AXIS);
  309.     c_token++;
  310.     } else if (almost_equals(c_token, "y2da$ta")) {
  311.     (void) putc('\n', stderr);
  312.     show_datatype("y2data", SECOND_Y_AXIS);
  313.     c_token++;
  314.     } else if (almost_equals(c_token, "zda$ta")) {
  315.     (void) putc('\n', stderr);
  316.     show_datatype("zdata", FIRST_Z_AXIS);
  317.     c_token++;
  318.     } else if (almost_equals(c_token, "timef$mt")) {
  319.     (void) putc('\n', stderr);
  320.     show_timefmt();
  321.     c_token++;
  322.     } else if (almost_equals(c_token, "loca$le")) {
  323.     (void) putc('\n', stderr);
  324.     show_locale();
  325.     c_token++;
  326.     } else if (almost_equals(c_token, "xzero$axis")) {
  327.     (void) putc('\n', stderr);
  328.     show_xzeroaxis();
  329.     c_token++;
  330.     } else if (almost_equals(c_token, "yzero$axis")) {
  331.     (void) putc('\n', stderr);
  332.     show_yzeroaxis();
  333.     c_token++;
  334.     } else if (almost_equals(c_token, "zeroa$xis")) {
  335.     (void) putc('\n', stderr);
  336.     show_xzeroaxis();
  337.     show_yzeroaxis();
  338.     c_token++;
  339.     } else if (almost_equals(c_token, "la$bel")) {
  340.     struct value a;
  341.     int tag = 0;
  342.  
  343.     c_token++;
  344.     if (!END_OF_COMMAND) {
  345.         tag = (int) real(const_express(&a));
  346.         if (tag <= 0)
  347.         int_error("tag must be > zero", c_token);
  348.     }
  349.     (void) putc('\n', stderr);
  350.     show_label(tag);
  351.     } else if (almost_equals(c_token, "li$nestyle") || equals(c_token, "ls")) {
  352.     struct value a;
  353.     int tag = 0;
  354.  
  355.     c_token++;
  356.     if (!END_OF_COMMAND) {
  357.         tag = (int) real(const_express(&a));
  358.         if (tag <= 0)
  359.         int_error("tag must be > zero", c_token);
  360.     }
  361.     (void) putc('\n', stderr);
  362.     show_linestyle(tag);
  363.     } else if (almost_equals(c_token, "g$rid")) {
  364.     (void) putc('\n', stderr);
  365.     show_grid();
  366.     c_token++;
  367.     } else if (almost_equals(c_token, "mxt$ics")) {
  368.     (void) putc('\n', stderr);
  369.     show_mtics(mxtics, mxtfreq, "x");
  370.     c_token++;
  371.     } else if (almost_equals(c_token, "myt$ics")) {
  372.     (void) putc('\n', stderr);
  373.     show_mtics(mytics, mytfreq, "y");
  374.     c_token++;
  375.     } else if (almost_equals(c_token, "mzt$ics")) {
  376.     (void) putc('\n', stderr);
  377.     show_mtics(mztics, mztfreq, "z");
  378.     c_token++;
  379.     } else if (almost_equals(c_token, "mx2t$ics")) {
  380.     (void) putc('\n', stderr);
  381.     show_mtics(mx2tics, mx2tfreq, "x2");
  382.     c_token++;
  383.     } else if (almost_equals(c_token, "my2t$ics")) {
  384.     (void) putc('\n', stderr);
  385.     show_mtics(my2tics, my2tfreq, "y2");
  386.     c_token++;
  387.     } else if (almost_equals(c_token, "k$ey")) {
  388.     (void) putc('\n', stderr);
  389.     show_key();
  390.     c_token++;
  391.     } else
  392.     return (FALSE);
  393.     return TRUE;
  394. }
  395.  
  396. /* return TRUE if a command match, FALSE if not */
  397. static TBOOLEAN
  398.  show_two()
  399. {
  400.     if (almost_equals(c_token, "p$lot")) {
  401.     (void) putc('\n', stderr);
  402.     show_plot();
  403.     c_token++;
  404.     } else if (almost_equals(c_token, "par$ametric")) {
  405.     (void) putc('\n', stderr);
  406.     show_parametric();
  407.     c_token++;
  408.     } else if (almost_equals(c_token, "poi$ntsize")) {
  409.     (void) putc('\n', stderr);
  410.     show_pointsize();
  411.     c_token++;
  412.     } else if (almost_equals(c_token, "enc$oding")) {
  413.     (void) putc('\n', stderr);
  414.     show_encoding();
  415.     c_token++;
  416.     } else if (almost_equals(c_token, "pol$ar")) {
  417.     (void) putc('\n', stderr);
  418.     show_polar();
  419.     c_token++;
  420.     } else if (almost_equals(c_token, "an$gles")) {
  421.     (void) putc('\n', stderr);
  422.     show_angles();
  423.     c_token++;
  424.     } else if (almost_equals(c_token, "ti$cs")) {
  425.     (void) putc('\n', stderr);
  426.     show_tics(TRUE, TRUE, TRUE, TRUE, TRUE);
  427.     c_token++;
  428.     } else if (almost_equals(c_token, "tim$estamp")) {
  429.     (void) putc('\n', stderr);
  430.     show_xyzlabel("time", &timelabel);
  431.     fprintf(stderr, "\twritten in %s corner\n", (timelabel_bottom ? "bottom" : "top"));
  432.     if (timelabel_rotate)
  433.         fputs("\trotated if the terminal allows it\n\t", stderr);
  434.     else
  435.         fputs("\tnot rotated\n\t", stderr);
  436.     c_token++;
  437.     } else if (almost_equals(c_token, "su$rface")) {
  438.     (void) putc('\n', stderr);
  439.     show_surface();
  440.     c_token++;
  441.     } else if (almost_equals(c_token, "hi$dden3d")) {
  442.     (void) putc('\n', stderr);
  443.     show_hidden3d();
  444.     c_token++;
  445.     } else if (almost_equals(c_token, "cla$bel")) {
  446.     (void) putc('\n', stderr);
  447.     show_label_contours();
  448.     c_token++;
  449.     } else if (almost_equals(c_token, "xti$cs")) {
  450.     show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
  451.     c_token++;
  452.     } else if (almost_equals(c_token, "yti$cs")) {
  453.     show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
  454.     c_token++;
  455.     } else if (almost_equals(c_token, "zti$cs")) {
  456.     show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
  457.     c_token++;
  458.     } else if (almost_equals(c_token, "x2ti$cs")) {
  459.     show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
  460.     c_token++;
  461.     } else if (almost_equals(c_token, "y2ti$cs")) {
  462.     show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
  463.     c_token++;
  464.     } else if (almost_equals(c_token, "xdti$cs")) {
  465.     show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
  466.     c_token++;
  467.     } else if (almost_equals(c_token, "ydti$cs")) {
  468.     show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
  469.     c_token++;
  470.     } else if (almost_equals(c_token, "zdti$cs")) {
  471.     show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
  472.     c_token++;
  473.     } else if (almost_equals(c_token, "x2dti$cs")) {
  474.     show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
  475.     c_token++;
  476.     } else if (almost_equals(c_token, "y2dti$cs")) {
  477.     show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
  478.     c_token++;
  479.     } else if (almost_equals(c_token, "xmti$cs")) {
  480.     show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
  481.     c_token++;
  482.     } else if (almost_equals(c_token, "ymti$cs")) {
  483.     show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
  484.     c_token++;
  485.     } else if (almost_equals(c_token, "zmti$cs")) {
  486.     show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
  487.     c_token++;
  488.     } else if (almost_equals(c_token, "x2mti$cs")) {
  489.     show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
  490.     c_token++;
  491.     } else if (almost_equals(c_token, "y2mti$cs")) {
  492.     show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
  493.     c_token++;
  494.     } else if (almost_equals(c_token, "sa$mples")) {
  495.     (void) putc('\n', stderr);
  496.     show_samples();
  497.     c_token++;
  498.     } else if (almost_equals(c_token, "isosa$mples")) {
  499.     (void) putc('\n', stderr);
  500.     show_isosamples();
  501.     c_token++;
  502.     } else if (almost_equals(c_token, "si$ze")) {
  503.     (void) putc('\n', stderr);
  504.     show_size();
  505.     c_token++;
  506.     } else if (almost_equals(c_token, "orig$in")) {
  507.     (void) putc('\n', stderr);
  508.     show_origin();
  509.     c_token++;
  510.     } else if (almost_equals(c_token, "t$erminal")) {
  511.     (void) putc('\n', stderr);
  512.     show_term();
  513.     c_token++;
  514.     } else if (almost_equals(c_token, "rr$ange")) {
  515.     (void) putc('\n', stderr);
  516.     show_range(R_AXIS, rmin, rmax, autoscale_r, "r");
  517.     c_token++;
  518.     } else if (almost_equals(c_token, "tr$ange")) {
  519.     (void) putc('\n', stderr);
  520.     show_range(T_AXIS, tmin, tmax, autoscale_t, "t");
  521.     c_token++;
  522.     } else if (almost_equals(c_token, "ur$ange")) {
  523.     (void) putc('\n', stderr);
  524.     show_range(U_AXIS, umin, umax, autoscale_u, "u");
  525.     c_token++;
  526.     } else if (almost_equals(c_token, "vi$ew")) {
  527.     (void) putc('\n', stderr);
  528.     show_view();
  529.     c_token++;
  530.     } else if (almost_equals(c_token, "vr$ange")) {
  531.     (void) putc('\n', stderr);
  532.     show_range(V_AXIS, vmin, vmax, autoscale_v, "v");
  533.     c_token++;
  534.     } else if (almost_equals(c_token, "v$ariables")) {
  535.     show_variables();
  536.     c_token++;
  537.     } else if (almost_equals(c_token, "ve$rsion")) {
  538.     show_version(stderr);
  539.     c_token++;
  540.     if (almost_equals(c_token, "l$ong")) {
  541.         show_version_long();
  542.         c_token++;
  543.     }
  544.     } else if (almost_equals(c_token, "xr$ange")) {
  545.     (void) putc('\n', stderr);
  546.     show_range(FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
  547.     c_token++;
  548.     } else if (almost_equals(c_token, "yr$ange")) {
  549.     (void) putc('\n', stderr);
  550.     show_range(FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
  551.     c_token++;
  552.     } else if (almost_equals(c_token, "x2r$ange")) {
  553.     (void) putc('\n', stderr);
  554.     show_range(SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
  555.     c_token++;
  556.     } else if (almost_equals(c_token, "y2r$ange")) {
  557.     (void) putc('\n', stderr);
  558.     show_range(SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
  559.     c_token++;
  560.     } else if (almost_equals(c_token, "zr$ange")) {
  561.     (void) putc('\n', stderr);
  562.     show_range(FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
  563.     c_token++;
  564.     } else if (almost_equals(c_token, "z$ero")) {
  565.     (void) putc('\n', stderr);
  566.     show_zero();
  567.     c_token++;
  568.     } else if (almost_equals(c_token, "a$ll")) {
  569.     c_token++;
  570.     show_version(stderr);
  571.     show_autoscale();
  572.     show_bars();
  573.     show_border();
  574.     show_boxwidth();
  575.     show_clip();
  576.     show_contour();
  577.     show_dgrid3d();
  578.     show_mapping();
  579.     (void) fprintf(stderr, "\tdummy variables are \"%s\" and \"%s\"\n",
  580.                dummy_var[0], dummy_var[1]);
  581.     show_format();
  582.     show_style("data", data_style);
  583.     show_style("functions", func_style);
  584.     show_grid();
  585.     show_xzeroaxis();
  586.     show_yzeroaxis();
  587.     show_label(0);
  588.     show_arrow(0);
  589.     show_linestyle(0);
  590.     show_keytitle();
  591.     show_key();
  592.     show_logscale();
  593.     show_offsets();
  594.     show_margin();
  595.     show_output();
  596.     show_parametric();
  597.     show_pointsize();
  598.     show_encoding();
  599.     show_polar();
  600.     show_angles();
  601.     show_samples();
  602.     show_isosamples();
  603.     show_view();
  604.     show_surface();
  605. #ifndef LITE
  606.     show_hidden3d();
  607. #endif
  608.     show_size();
  609.     show_origin();
  610.     show_term();
  611.     show_tics(TRUE, TRUE, TRUE, TRUE, TRUE);
  612.     show_mtics(mxtics, mxtfreq, "x");
  613.     show_mtics(mytics, mytfreq, "y");
  614.     show_mtics(mztics, mztfreq, "z");
  615.     show_mtics(mx2tics, mx2tfreq, "x2");
  616.     show_mtics(my2tics, my2tfreq, "y2");
  617.     show_xyzlabel("time", &timelabel);
  618.     if (parametric || polar) {
  619.         if (!is_3d_plot)
  620.         show_range(T_AXIS, tmin, tmax, autoscale_t, "t");
  621.         else {
  622.         show_range(U_AXIS, umin, umax, autoscale_u, "u");
  623.         show_range(V_AXIS, vmin, vmax, autoscale_v, "v");
  624.         }
  625.     }
  626.     show_range(FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
  627.     show_range(FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
  628.     show_range(SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
  629.     show_range(SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
  630.     show_range(FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
  631.     show_xyzlabel("title", &title);
  632.     show_xyzlabel("xlabel", &xlabel);
  633.     show_xyzlabel("ylabel", &ylabel);
  634.     show_xyzlabel("zlabel", &zlabel);
  635.     show_xyzlabel("x2label", &x2label);
  636.     show_xyzlabel("y2label", &y2label);
  637.     show_datatype("xdata", FIRST_X_AXIS);
  638.     show_datatype("ydata", FIRST_Y_AXIS);
  639.     show_datatype("x2data", SECOND_X_AXIS);
  640.     show_datatype("y2data", SECOND_Y_AXIS);
  641.     show_datatype("zdata", FIRST_Z_AXIS);
  642.     show_timefmt();
  643.     show_locale();
  644.     show_zero();
  645.     show_missing();
  646.     show_plot();
  647.     show_variables();
  648.     show_functions();
  649.     c_token++;
  650.     } else
  651.     return (FALSE);
  652.     return (TRUE);
  653. }
  654.  
  655.  
  656. /*********** support functions for 'show'  **********/
  657. /* perhaps these need to be put into a constant array ? */
  658. static void show_style(name, style)
  659. char name[];
  660. enum PLOT_STYLE style;
  661. {
  662.     fprintf(stderr, "\t%s are plotted with ", name);
  663.     switch (style) {
  664.     case LINES:
  665.     fputs("lines\n", stderr);
  666.     break;
  667.     case POINTSTYLE:
  668.     fputs("points\n", stderr);
  669.     break;
  670.     case IMPULSES:
  671.     fputs("impulses\n", stderr);
  672.     break;
  673.     case LINESPOINTS:
  674.     fputs("linespoints\n", stderr);
  675.     break;
  676.     case DOTS:
  677.     fputs("dots\n", stderr);
  678.     break;
  679.     case YERRORBARS:
  680.     fputs("yerrorbars\n", stderr);
  681.     break;
  682.     case XERRORBARS:
  683.     fputs("xerrorbars\n", stderr);
  684.     break;
  685.     case XYERRORBARS:
  686.     fputs("xyerrorbars\n", stderr);
  687.     break;
  688.     case BOXES:
  689.     fputs("boxes\n", stderr);
  690.     break;
  691.     case BOXERROR:
  692.     fputs("boxerrorbars\n", stderr);
  693.     break;
  694.     case BOXXYERROR:
  695.     fputs("boxxyerrorbars\n", stderr);
  696.     break;
  697.     case STEPS:
  698.     fputs("steps\n", stderr);
  699.     break;
  700.     case FSTEPS:
  701.     fputs("fsteps\n", stderr);
  702.     break;
  703.     case HISTEPS:
  704.     fputs("histeps\n", stderr);
  705.     break;
  706.     case VECTOR:
  707.     fputs("vector\n", stderr);
  708.     break;
  709.     case FINANCEBARS:
  710.     fputs("financebars\n", stderr);
  711.     break;
  712.     case CANDLESTICKS:
  713.     fputs("candlesticsks\n", stderr);
  714.     break;
  715.     }
  716. }
  717.  
  718. static void show_bars()
  719. {
  720.     /* I really like this: "terrorbars" ;-) */
  721.     if (bar_size > 0.0)
  722.     fprintf(stderr, "\terrorbars are plotted with bars of size %f\n",
  723.         bar_size);
  724.     else
  725.     fputs("\terrors are plotted without bars\n", stderr);
  726. }
  727.  
  728. static void show_boxwidth()
  729. {
  730.     if (boxwidth < 0.0)
  731.     fputs("\tboxwidth is auto\n", stderr);
  732.     else
  733.     fprintf(stderr, "\tboxwidth is %g\n", boxwidth);
  734. }
  735. static void show_dgrid3d()
  736. {
  737.     if (dgrid3d)
  738.     fprintf(stderr, "\
  739. \tdata grid3d is enabled for mesh of size %dx%d, norm=%d\n",
  740.         dgrid3d_row_fineness,
  741.         dgrid3d_col_fineness,
  742.         dgrid3d_norm_value);
  743.     else
  744.     fputs("\tdata grid3d is disabled\n", stderr);
  745. }
  746.  
  747. static void show_range(axis, min, max, autosc, text)
  748. int axis;
  749. double min, max;
  750. TBOOLEAN autosc;
  751. char *text;
  752. {
  753.     /* this probably ought to just invoke save_range(stderr) from misc.c
  754.      * since I think it is identical
  755.      */
  756.  
  757.     if (datatype[axis] == TIME)
  758.     fprintf(stderr, "\tset %sdata time\n", text);
  759.     fprintf(stderr, "\tset %srange [", text);
  760.     if (autosc & 1) {
  761.     fputc('*', stderr);
  762.     } else {
  763.     SHOW_NUM_OR_TIME(min, axis);
  764.     }
  765.     fputs(" : ", stderr);
  766.     if (autosc & 2) {
  767.     fputc('*', stderr);
  768.     } else {
  769.     SHOW_NUM_OR_TIME(max, axis);
  770.     }
  771.     fprintf(stderr, "] %sreverse %swriteback",
  772.         (range_flags[axis] & RANGE_REVERSE) ? "" : "no",
  773.         (range_flags[axis] & RANGE_WRITEBACK) ? "" : "no");
  774.  
  775.     if (autosc) {
  776.     /* add current (hidden) range as comments */
  777.     fputs("  # (currently [", stderr);
  778.     if (autosc & 1) {
  779.         SHOW_NUM_OR_TIME(min, axis);
  780.     }
  781.     putc(':', stderr);
  782.     if (autosc & 2) {
  783.         SHOW_NUM_OR_TIME(max, axis);
  784.     }
  785.     fputs("] )\n", stderr);
  786.     } else {
  787.     putc('\n', stderr);
  788.     }
  789. }
  790.  
  791. static void show_zero()
  792. {
  793.     fprintf(stderr, "\tzero is %g\n", zero);
  794. }
  795.  
  796. static void show_offsets()
  797. {
  798.     fprintf(stderr, "\toffsets are %g, %g, %g, %g\n", loff, roff, toff, boff);
  799. }
  800.  
  801. static void show_border()
  802. {
  803.     fprintf(stderr, "\tborder is %sdrawn %d\n", draw_border ? "" : "not ",
  804.         draw_border);
  805.     /* HBB 980609: added facilities to specify border linestyle */
  806.     fprintf(stderr, "\tBorder drawn with linetype %d, linewidth %.3f\n",
  807.         border_lp.l_type + 1, border_lp.l_width);
  808. }
  809.  
  810. static void show_output()
  811. {
  812.     if (outstr)
  813.     fprintf(stderr, "\toutput is sent to '%s'\n", outstr);
  814.     else
  815.     fputs("\toutput is sent to STDOUT\n", stderr);
  816. }
  817.  
  818. static void show_samples()
  819. {
  820.     fprintf(stderr, "\tsampling rate is %d, %d\n", samples_1, samples_2);
  821. }
  822.  
  823. static void show_isosamples()
  824. {
  825.     fprintf(stderr, "\tiso sampling rate is %d, %d\n",
  826.         iso_samples_1, iso_samples_2);
  827. }
  828.  
  829. static void show_surface()
  830. {
  831.     fprintf(stderr, "\tsurface is %sdrawn\n", draw_surface ? "" : "not ");
  832. }
  833.  
  834. static void show_hidden3d()
  835. {
  836. #ifdef LITE
  837.     printf(" Hidden Line Removal Not Supported in LITE version\n");
  838. #else
  839.     fprintf(stderr, "\thidden surface is %s\n", hidden3d ? "removed" : "drawn");
  840.     show_hidden3doptions();
  841. #endif /* LITE */
  842. }
  843.  
  844. static void show_label_contours()
  845. {
  846.     if (label_contours)
  847.     fprintf(stderr, "\tcontour line types are varied & labeled with format '%s'\n", contour_format);
  848.     else
  849.     fputs("\tcontour line types are all the same\n", stderr);
  850. }
  851.  
  852. static void show_view()
  853. {
  854.     fprintf(stderr, "\tview is %g rot_x, %g rot_z, %g scale, %g scale_z\n",
  855.         surface_rot_x, surface_rot_z, surface_scale, surface_zscale);
  856. }
  857.  
  858. static void show_size()
  859. {
  860.     fprintf(stderr, "\tsize is scaled by %g,%g\n", xsize, ysize);
  861.     if (aspect_ratio > 0)
  862.     fprintf(stderr, "\tTry to set aspect ratio to %g:1.0\n", aspect_ratio);
  863.     else if (aspect_ratio == 0)
  864.     fputs("\tNo attempt to control aspect ratio\n", stderr);
  865.     else
  866.     fprintf(stderr, "\tTry to set LOCKED aspect ratio to %g:1.0\n",
  867.         -aspect_ratio);
  868. }
  869.  
  870. static void show_origin()
  871. {
  872.     fprintf(stderr, "\torigin is set to %g,%g\n", xoffset, yoffset);
  873. }
  874.  
  875. static void show_xyzlabel(name, label)
  876. char *name;
  877. label_struct *label;
  878. {
  879.     char str[MAX_LINE_LEN + 1];
  880.     fprintf(stderr, "\t%s is \"%s\", offset at %f, %f",
  881.       name, conv_text(str, label->text), label->xoffset, label->yoffset);
  882.     if (*label->font)
  883.     fprintf(stderr, ", using font \"%s\"", conv_text(str, label->font));
  884.     putc('\n', stderr);
  885. }
  886.  
  887. static void show_keytitle()
  888. {
  889.     char str[MAX_LINE_LEN+1];
  890.     fprintf(stderr, "\tkeytitle is \"%s\"\n",
  891.         conv_text(str, key_title));
  892. }
  893.  
  894. static void show_timefmt()
  895. {
  896.     char str[MAX_LINE_LEN+1];
  897.     fprintf(stderr, "\tread format for time is \"%s\"\n",
  898.         conv_text(str, timefmt));
  899. }
  900.  
  901. static void show_locale()
  902. {
  903.     fprintf(stderr, "\tlocale is \"%s\"\n", cur_locale);
  904. }
  905.  
  906. static void show_xzeroaxis()
  907. {
  908.     if (xzeroaxis.l_type > -3)
  909.     fprintf(stderr, "\txzeroaxis is drawn with linestyle %d, linewidth %.3f\n", xzeroaxis.l_type + 1, xzeroaxis.l_width);
  910.     else
  911.     fputs("\txzeroaxis is OFF\n", stderr);
  912.     if (x2zeroaxis.l_type > -3)
  913.     fprintf(stderr, "\tx2zeroaxis is drawn with linestyle %d, linewidth %.3f\n", x2zeroaxis.l_type + 1, x2zeroaxis.l_width);
  914.     else
  915.     fputs("\tx2zeroaxis is OFF\n", stderr);
  916. }
  917.  
  918. static void show_yzeroaxis()
  919. {
  920.     if (yzeroaxis.l_type > -3)
  921.     fprintf(stderr, "\tyzeroaxis is drawn with linestyle %d, linewidth %.3f\n", yzeroaxis.l_type + 1, yzeroaxis.l_width);
  922.     else
  923.     fputs("\tyzeroaxis is OFF\n", stderr);
  924.     if (y2zeroaxis.l_type > -3)
  925.     fprintf(stderr, "\ty2zeroaxis is drawn with linestyle %d, linewidth %.3f\n", y2zeroaxis.l_type + 1, y2zeroaxis.l_width);
  926.     else
  927.     fputs("\ty2zeroaxis is OFF\n", stderr);
  928. }
  929.  
  930. static void show_label(tag)
  931. int tag;            /* 0 means show all */
  932. {
  933.     struct text_label *this_label;
  934.     TBOOLEAN showed = FALSE;
  935.     char str[MAX_LINE_LEN + 1];
  936.  
  937.     for (this_label = first_label; this_label != NULL;
  938.      this_label = this_label->next) {
  939.     if (tag == 0 || tag == this_label->tag) {
  940.         showed = TRUE;
  941.         fprintf(stderr, "\tlabel %d \"%s\" at ",
  942.             this_label->tag, conv_text(str, this_label->text));
  943.         show_position(&this_label->place);
  944.         switch (this_label->pos) {
  945.         case LEFT:{
  946.             fputs(" left", stderr);
  947.             break;
  948.         }
  949.         case CENTRE:{
  950.             fputs(" centre", stderr);
  951.             break;
  952.         }
  953.         case RIGHT:{
  954.             fputs(" right", stderr);
  955.             break;
  956.         }
  957.         }
  958.         fprintf(stderr, " %s ", this_label->rotate ? "rotated (if possible)" : "not rotated");
  959.         if ((this_label->font)[0] != NUL)
  960.         fprintf(stderr, " font \"%s\"", this_label->font);
  961.         /* Entry font added by DJL */
  962.         fputc('\n', stderr);
  963.     }
  964.     }
  965.     if (tag > 0 && !showed)
  966.     int_error("label not found", c_token);
  967. }
  968.  
  969. static void show_arrow(tag)
  970. int tag;            /* 0 means show all */
  971. {
  972.     struct arrow_def *this_arrow;
  973.     TBOOLEAN showed = FALSE;
  974.  
  975.     for (this_arrow = first_arrow; this_arrow != NULL;
  976.      this_arrow = this_arrow->next) {
  977.     if (tag == 0 || tag == this_arrow->tag) {
  978.         showed = TRUE;
  979.         fprintf(stderr, "\tarrow %d, linetype %d, linewidth %.3f %s\n\t  from ",
  980.             this_arrow->tag,
  981.             this_arrow->lp_properties.l_type + 1,
  982.             this_arrow->lp_properties.l_width,
  983.             this_arrow->head ? "" : " (nohead)");
  984.         show_position(&this_arrow->start);
  985.         fputs(" to ", stderr);
  986.         show_position(&this_arrow->end);
  987.         putc('\n', stderr);
  988.     }
  989.     }
  990.     if (tag > 0 && !showed)
  991.     int_error("arrow not found", c_token);
  992. }
  993.  
  994. static void show_linestyle(tag)
  995. int tag;            /* 0 means show all */
  996. {
  997.     struct linestyle_def *this_linestyle;
  998.     TBOOLEAN showed = FALSE;
  999.  
  1000.     for (this_linestyle = first_linestyle; this_linestyle != NULL;
  1001.      this_linestyle = this_linestyle->next) {
  1002.     if (tag == 0 || tag == this_linestyle->tag) {
  1003.         showed = TRUE;
  1004.         fprintf(stderr, "\tlinestyle %d, linetype %d, linewidth %.3f, pointtype %d, pointsize %.3f\n",
  1005.             this_linestyle->tag,
  1006.             this_linestyle->lp_properties.l_type + 1,
  1007.             this_linestyle->lp_properties.l_width,
  1008.             this_linestyle->lp_properties.p_type + 1,
  1009.             this_linestyle->lp_properties.p_size);
  1010.     }
  1011.     }
  1012.     if (tag > 0 && !showed)
  1013.     int_error("linestyle not found", c_token);
  1014. }
  1015.  
  1016. static void show_grid()
  1017. {
  1018.     if (!work_grid.l_type) {
  1019.     fputs("\tgrid is OFF\n", stderr);
  1020.     return;
  1021.     }
  1022.     fprintf(stderr, "\t%s grid drawn at%s%s%s%s%s%s%s%s%s%s tics\n",
  1023.         (polar_grid_angle != 0) ? "Polar" : "Rectangular",
  1024.         work_grid.l_type & GRID_X ? " x" : "",
  1025.         work_grid.l_type & GRID_Y ? " y" : "",
  1026.         work_grid.l_type & GRID_Z ? " z" : "",
  1027.         work_grid.l_type & GRID_X2 ? " x2" : "",
  1028.         work_grid.l_type & GRID_Y2 ? " y2" : "",
  1029.         work_grid.l_type & GRID_MX ? " mx" : "",
  1030.         work_grid.l_type & GRID_MY ? " my" : "",
  1031.         work_grid.l_type & GRID_MZ ? " mz" : "",
  1032.         work_grid.l_type & GRID_MX2 ? " mx2" : "",
  1033.         work_grid.l_type & GRID_MY2 ? " my2" : "");
  1034.  
  1035.     fprintf(stderr, "\tMajor grid drawn with linetype %d, linewidth %.3f\n",
  1036.         grid_lp.l_type + 1, grid_lp.l_width);
  1037.     fprintf(stderr, "\tMinor grid drawn with linetype %d, linewidth %.3f\n",
  1038.         mgrid_lp.l_type + 1, mgrid_lp.l_width);
  1039.  
  1040.     if (polar_grid_angle)
  1041.     fprintf(stderr, "\tGrid radii drawn every %f %s\n",
  1042.         polar_grid_angle / ang2rad,
  1043.         angles_format == ANGLES_DEGREES ? "degrees" : "radians");
  1044. }
  1045.  
  1046. static void show_mtics(minitic, minifreq, name)
  1047. int minitic;
  1048. double minifreq;
  1049. char *name;
  1050. {
  1051.     switch (minitic) {
  1052.     case MINI_OFF:
  1053.     fprintf(stderr, "\tminor %stics are off\n", name);
  1054.     break;
  1055.     case MINI_DEFAULT:
  1056.     fprintf(stderr, "\tminor %stics are computed automatically for log scales\n", name);
  1057.     break;
  1058.     case MINI_AUTO:
  1059.     fprintf(stderr, "\tminor %stics are computed automatically\n", name);
  1060.     break;
  1061.     case MINI_USER:
  1062.     fprintf(stderr, "\tminor %stics are drawn with %d subintervals between major xtic marks\n", name, (int) minifreq);
  1063.     break;
  1064.     default:
  1065.     int_error("Unknown minitic type in show_mtics()", NO_CARET);
  1066.     }
  1067. }
  1068.  
  1069. static void show_key()
  1070. {
  1071.     char str[80];
  1072.     *str = '\0';
  1073.     switch (key) {
  1074.     case -1:
  1075.     if (key_vpos == TUNDER) {
  1076.         strcpy(str, "below");
  1077.     } else if (key_vpos == TTOP) {
  1078.         strcpy(str, "top");
  1079.     } else {
  1080.         strcpy(str, "bottom");
  1081.     }
  1082.     if (key_hpos == TOUT) {
  1083.         strcpy(str, "outside (right)");
  1084.     } else if (key_hpos == TLEFT) {
  1085.         strcat(str, " left");
  1086.     } else {
  1087.         strcat(str, " right");
  1088.     }
  1089.     if (key_vpos != TUNDER && key_hpos != TOUT) {
  1090.         strcat(str, " corner");
  1091.     }
  1092.     fprintf(stderr, "\tkey is ON, position: %s\n", str);
  1093.     break;
  1094.     case 0:
  1095.     fputs("\tkey is OFF\n", stderr);
  1096.     break;
  1097.     case 1:
  1098.     fputs("\tkey is at ", stderr);
  1099.     show_position(&key_user_pos);
  1100.     putc('\n', stderr);
  1101.     break;
  1102.     }
  1103.     if (key) {
  1104.     fprintf(stderr, "\tkey is %s justified, %s reversed and ",
  1105.         key_just == JLEFT ? "left" : "right",
  1106.         key_reverse ? "" : "not");
  1107.     if (key_box.l_type >= -2)
  1108.         fprintf(stderr, "boxed\n\twith linetype %d, linewidth %.3f\n",
  1109.             key_box.l_type + 1, key_box.l_width);
  1110.     else
  1111.         fprintf(stderr, "not boxed\n\
  1112. \tsample length is %g characters\n\
  1113. \tvertical spacing is %g characters\n\
  1114. \twidth adjustment is %g characters\n\
  1115. \tkey title is \"%s\"\n",
  1116.     key_swidth,
  1117.     key_vert_factor,
  1118.     key_width_fix,
  1119.     key_title);
  1120.     }
  1121. }
  1122.  
  1123. static void show_parametric()
  1124. {
  1125.     fprintf(stderr, "\tparametric is %s\n", (parametric) ? "ON" : "OFF");
  1126. }
  1127.  
  1128. static void show_pointsize()
  1129. {
  1130.     fprintf(stderr, "\tpointsize is %g\n", pointsize);
  1131. }
  1132.  
  1133. static void show_encoding()
  1134. {
  1135.     fprintf(stderr, "\tencoding is %s\n", encoding_names[encoding]);
  1136. }
  1137.  
  1138. static void show_polar()
  1139. {
  1140.     fprintf(stderr, "\tpolar is %s\n", (polar) ? "ON" : "OFF");
  1141. }
  1142.  
  1143. static void show_angles()
  1144. {
  1145.     fputs("\tAngles are in ", stderr);
  1146.     switch (angles_format) {
  1147.     case ANGLES_RADIANS:
  1148.     fputs("radians\n", stderr);
  1149.     break;
  1150.     case ANGLES_DEGREES:
  1151.     fputs("degrees\n", stderr);
  1152.     break;
  1153.     }
  1154. }
  1155.  
  1156.  
  1157. static void show_tics(showx, showy, showz, showx2, showy2)
  1158. TBOOLEAN showx, showy, showz, showx2, showy2;
  1159. {
  1160.     char str[MAX_LINE_LEN+1];
  1161.     fprintf(stderr, "\ttics are %s, \
  1162. \tticslevel is %g\n\
  1163. \tmajor ticscale is %g and minor ticscale is %g\n",
  1164.         (tic_in ? "IN" : "OUT"),
  1165.         ticslevel,
  1166.         ticscale, miniticscale);
  1167.  
  1168.     if (showx)
  1169.     show_ticdef(xtics, FIRST_X_AXIS, &xticdef, "x", rotate_xtics,
  1170.         conv_text(str, xformat));
  1171.     if (showx2)
  1172.     show_ticdef(x2tics, SECOND_X_AXIS, &x2ticdef, "x2", rotate_x2tics,
  1173.         conv_text(str, x2format));
  1174.     if (showy)
  1175.     show_ticdef(ytics, FIRST_Y_AXIS, &yticdef, "y", rotate_ytics,
  1176.         conv_text(str, yformat));
  1177.     if (showy2)
  1178.     show_ticdef(y2tics, SECOND_Y_AXIS, &y2ticdef, "y2", rotate_y2tics,
  1179.         conv_text(str, y2format));
  1180.     if (showz)
  1181.     show_ticdef(ztics, FIRST_Z_AXIS, &zticdef, "z", rotate_ztics,
  1182.         conv_text(str, zformat));
  1183.     screen_ok = FALSE;
  1184. }
  1185.  
  1186. /* called by show_tics */
  1187. static void show_ticdef(tics, axis, tdef, text, rotate_tics, ticfmt)
  1188. int tics;            /* xtics ytics or ztics */
  1189. int axis;
  1190. struct ticdef *tdef;        /* xticdef yticdef or zticdef */
  1191. char *text;            /* "x", ..., "x2", "y2" */
  1192. char *ticfmt;
  1193. int rotate_tics;
  1194. {
  1195.     register struct ticmark *t;
  1196.  
  1197.     fprintf(stderr, "\t%s-axis tics:\t", text);
  1198.     switch (tics & TICS_MASK) {
  1199.     case NO_TICS:
  1200.     fputs("OFF\n", stderr);
  1201.     return;
  1202.     case TICS_ON_AXIS:
  1203.     fputs("on axis", stderr);
  1204.         if (tics & TICS_MIRROR)
  1205.             fprintf(stderr, " and mirrored %s", (tic_in ? "OUT" : "IN"));
  1206.     break;
  1207.     case TICS_ON_BORDER:
  1208.     fputs("on border", stderr);
  1209.         if (tics & TICS_MIRROR)
  1210.             fputs(" and mirrored on opposite border", stderr);
  1211.     break;
  1212.     }
  1213.  
  1214.     fprintf(stderr,"\n\t  labels are format \"%s\"", ticfmt);
  1215.     if (rotate_tics)
  1216.     fputs(", rotated in 2D mode, terminal permitting.\n\t", stderr);
  1217.     else
  1218.     fputs(" and are not rotated\n\t", stderr);
  1219.  
  1220.     switch (tdef->type) {
  1221.     case TIC_COMPUTED:{
  1222.         fputs("  intervals computed automatically\n", stderr);
  1223.         break;
  1224.     }
  1225.     case TIC_MONTH:{
  1226.         fputs("  Months computed automatically\n", stderr);
  1227.         break;
  1228.     }
  1229.     case TIC_DAY:{
  1230.         fputs("  Days computed automatically\n", stderr);
  1231.         break;
  1232.     }
  1233.     case TIC_SERIES:{
  1234.         fputs("  series", stderr);
  1235.         if (tdef->def.series.start != -VERYLARGE) {
  1236.         fputs(" from ", stderr);
  1237.         SHOW_NUM_OR_TIME(tdef->def.series.start, axis);
  1238.         }
  1239.         fprintf(stderr, " by %g%s", tdef->def.series.incr, datatype[axis] == TIME ? " secs" : "");
  1240.         if (tdef->def.series.end != VERYLARGE) {
  1241.         fputs(" until ", stderr);
  1242.         SHOW_NUM_OR_TIME(tdef->def.series.end, axis);
  1243.         }
  1244.         putc('\n', stderr);
  1245.         break;
  1246.     }
  1247.     case TIC_USER:{
  1248. /* this appears to be unused? lh
  1249.         int time;
  1250.         time = (datatype[axis] == TIME);
  1251.  */
  1252.         fputs("  list (", stderr);
  1253.         for (t = tdef->def.user; t != NULL; t = t->next) {
  1254.         if (t->label) {
  1255.             char str[MAX_LINE_LEN+1];
  1256.             fprintf(stderr, "\"%s\" ", conv_text(str, t->label));
  1257.         }
  1258.         SHOW_NUM_OR_TIME(t->position, axis);
  1259.         if (t->next)
  1260.             fputs(", ", stderr);
  1261.         }
  1262.         fputs(")\n", stderr);
  1263.         break;
  1264.     }
  1265.     default:{
  1266.         int_error("unknown ticdef type in show_ticdef()", NO_CARET);
  1267.         /* NOTREACHED */
  1268.     }
  1269.     }
  1270. }
  1271.  
  1272.  
  1273. static void show_margin()
  1274. {
  1275.     if (lmargin >= 0)
  1276.     fprintf(stderr, "\tlmargin is set to %d\n", lmargin);
  1277.     else
  1278.     fputs("\tlmargin is computed automatically\n", stderr);
  1279.     if (bmargin >= 0)
  1280.     fprintf(stderr, "\tbmargin is set to %d\n", bmargin);
  1281.     else
  1282.     fputs("\tbmargin is computed automatically\n", stderr);
  1283.     if (rmargin >= 0)
  1284.     fprintf(stderr, "\trmargin is set to %d\n", rmargin);
  1285.     else
  1286.     fputs("\trmargin is computed automatically\n", stderr);
  1287.     if (tmargin >= 0)
  1288.     fprintf(stderr, "\ttmargin is set to %d\n", tmargin);
  1289.     else
  1290.     fputs("\ttmargin is computed automatically\n", stderr);
  1291. }
  1292.  
  1293. static void show_term()
  1294. {
  1295.     if (term)
  1296.     fprintf(stderr, "\tterminal type is %s %s\n",
  1297.         term->name, term_options);
  1298.     else
  1299.     fputs("\tterminal type is unknown\n", stderr);
  1300. }
  1301.  
  1302. static void show_plot()
  1303. {
  1304.     fprintf(stderr, "\tlast plot command was: %s\n", replot_line);
  1305. }
  1306.  
  1307. static void show_autoscale()
  1308. {
  1309.     fputs("\tautoscaling is ", stderr);
  1310.     if (parametric) {
  1311.     if (is_3d_plot) {
  1312.         fprintf(stderr, "\tt: %s%s%s, ",
  1313.             (autoscale_t) ? "ON" : "OFF",
  1314.             (autoscale_t == 1) ? " (min)" : "",
  1315.             (autoscale_t == 2) ? " (max)" : "");
  1316.     } else {
  1317.         fprintf(stderr, "\tu: %s%s%s, ",
  1318.             (autoscale_u) ? "ON" : "OFF",
  1319.             (autoscale_u == 1) ? " (min)" : "",
  1320.             (autoscale_u == 2) ? " (max)" : "");
  1321.         fprintf(stderr, "v: %s%s%s, ",
  1322.             (autoscale_v) ? "ON" : "OFF",
  1323.             (autoscale_v == 1) ? " (min)" : "",
  1324.             (autoscale_v == 2) ? " (max)" : "");
  1325.     }
  1326.     } else
  1327.     putc('\t', stderr);
  1328.  
  1329.     if (polar) {
  1330.     fprintf(stderr, "r: %s%s%s, ", (autoscale_r) ? "ON" : "OFF",
  1331.         (autoscale_r == 1) ? " (min)" : "",
  1332.         (autoscale_r == 2) ? " (max)" : "");
  1333.     }
  1334.     fprintf(stderr, "x: %s%s%s, ", (autoscale_x) ? "ON" : "OFF",
  1335.         (autoscale_x == 1) ? " (min)" : "",
  1336.         (autoscale_x == 2) ? " (max)" : "");
  1337.     fprintf(stderr, "y: %s%s%s, ", (autoscale_y) ? "ON" : "OFF",
  1338.         (autoscale_y == 1) ? " (min)" : "",
  1339.         (autoscale_y == 2) ? " (max)" : "");
  1340.     fprintf(stderr, "z: %s%s%s\n", (autoscale_z) ? "ON" : "OFF",
  1341.         (autoscale_z == 1) ? " (min)" : "",
  1342.         (autoscale_z == 2) ? " (max)" : "");
  1343. }
  1344.  
  1345. static void show_clip()
  1346. {
  1347.     fprintf(stderr, "\tpoint clip is %s\n", (clip_points) ? "ON" : "OFF");
  1348.  
  1349.     if (clip_lines1)
  1350.     fputs("\tdrawing and clipping lines between inrange and outrange points\n", stderr);
  1351.     else
  1352.     fputs("\tnot drawing lines between inrange and outrange points\n", stderr);
  1353.  
  1354.     if (clip_lines2)
  1355.     fputs("\tdrawing and clipping lines between two outrange points\n", stderr);
  1356.     else
  1357.     fputs("\tnot drawing lines between two outrange points\n", stderr);
  1358. }
  1359.  
  1360. static void show_mapping()
  1361. {
  1362.     fputs("\tmapping for 3-d data is ", stderr);
  1363.  
  1364.     switch (mapping3d) {
  1365.     case MAP3D_CARTESIAN:
  1366.     fputs("cartesian\n", stderr);
  1367.     break;
  1368.     case MAP3D_SPHERICAL:
  1369.     fputs("spherical\n", stderr);
  1370.     break;
  1371.     case MAP3D_CYLINDRICAL:
  1372.     fputs("cylindrical\n", stderr);
  1373.     break;
  1374.     }
  1375. }
  1376.  
  1377. static void show_contour()
  1378. {
  1379.     fprintf(stderr, "\tcontour for surfaces are %s",
  1380.         (draw_contour) ? "drawn" : "not drawn\n");
  1381.  
  1382.     if (draw_contour) {
  1383.     fprintf(stderr, " in %d levels on ", contour_levels);
  1384.     switch (draw_contour) {
  1385.     case CONTOUR_BASE:
  1386.         fputs("grid base\n", stderr);
  1387.         break;
  1388.     case CONTOUR_SRF:
  1389.         fputs("surface\n", stderr);
  1390.         break;
  1391.     case CONTOUR_BOTH:
  1392.         fputs("grid base and surface\n", stderr);
  1393.         break;
  1394.     }
  1395.     switch (contour_kind) {
  1396.     case CONTOUR_KIND_LINEAR:
  1397.         fputs("\t\tas linear segments\n", stderr);
  1398.         break;
  1399.     case CONTOUR_KIND_CUBIC_SPL:
  1400.         fprintf(stderr, "\t\tas cubic spline interpolation segments with %d pts\n", contour_pts);
  1401.         break;
  1402.     case CONTOUR_KIND_BSPLINE:
  1403.         fprintf(stderr, "\t\tas bspline approximation segments of order %d with %d pts\n", contour_order, contour_pts);
  1404.         break;
  1405.     }
  1406.     switch (levels_kind) {
  1407.     case LEVELS_AUTO:
  1408.         fprintf(stderr, "\t\tapprox. %d automatic levels\n", contour_levels);
  1409.         break;
  1410.     case LEVELS_DISCRETE:
  1411.         {
  1412.         int i;
  1413.         fprintf(stderr, "\t\t%d discrete levels at ", contour_levels);
  1414.         fprintf(stderr, "%g", levels_list[0]);
  1415.         for (i = 1; i < contour_levels; i++)
  1416.             fprintf(stderr, ",%g ", levels_list[i]);
  1417.         putc('\n', stderr);
  1418.         break;
  1419.         }
  1420.     case LEVELS_INCREMENTAL:
  1421.         fprintf(stderr, "\t\t%d incremental levels starting at %g, step %g, end %g\n", contour_levels, levels_list[0], levels_list[1],
  1422.          levels_list[0] + (contour_levels - 1) * levels_list[1]);
  1423.         /* contour-levels counts both ends */
  1424.         break;
  1425.     }
  1426.     /* fprintf(stderr,"\t\tcontour line types are %s\n", label_contours ? "varied" : "all the same"); */
  1427.     show_label_contours();
  1428.     }
  1429. }
  1430.  
  1431. static void show_format()
  1432. {
  1433.     char str[5][MAX_LINE_LEN + 1];
  1434.  
  1435.     fprintf(stderr, "\ttic format is x-axis: \"%s\"\
  1436. , y-axis: \"%s\"\
  1437. , z-axis: \"%s\"\
  1438. , x2-axis: \"%s\"\
  1439. , y2-axis: \"%s\"\n",
  1440.         conv_text(str[0], xformat),
  1441.         conv_text(str[1], yformat),
  1442.         conv_text(str[2], zformat),
  1443.         conv_text(str[3], x2format),
  1444.         conv_text(str[4], y2format));
  1445. }
  1446.  
  1447. #define SHOW_LOG(FLAG, BASE, TEXT) \
  1448. if (FLAG) fprintf(stderr, "%s %s (base %g)", !count++ ? "\tlogscaling" : " and", TEXT,BASE)
  1449.  
  1450. static void show_logscale()
  1451. {
  1452.     int count = 0;
  1453.  
  1454.     SHOW_LOG(is_log_x, base_log_x, "x");
  1455.     SHOW_LOG(is_log_y, base_log_y, "y");
  1456.     SHOW_LOG(is_log_z, base_log_z, "z");
  1457.     SHOW_LOG(is_log_x2, base_log_x2, "x2");
  1458.     SHOW_LOG(is_log_y2, base_log_y2, "y2");
  1459.  
  1460.     if (count == 0)
  1461.     fputs("\tno logscaling\n", stderr);
  1462.     else if (count == 1)
  1463.     fputs(" only\n", stderr);
  1464.     else
  1465.     putc('\n', stderr);
  1466. }
  1467.  
  1468. static void show_variables()
  1469. {
  1470.     register struct udvt_entry *udv = first_udv;
  1471.     int len;
  1472.  
  1473.     fputs("\n\tVariables:\n", stderr);
  1474.     while (udv) {
  1475.     len = instring(udv->udv_name, ' ');
  1476.     fprintf(stderr, "\t%-*s ", len, udv->udv_name);
  1477.     if (udv->udv_undef)
  1478.         fputs("is undefined\n", stderr);
  1479.     else {
  1480.         fputs("= ", stderr);
  1481.         disp_value(stderr, &(udv->udv_value));
  1482.         (void) putc('\n', stderr);
  1483.     }
  1484.     udv = udv->next_udv;
  1485.     }
  1486. }
  1487.  
  1488. /*
  1489.  * Used in plot.c and misc.c
  1490.  * By adding FILE *fp, we can now use show_version()
  1491.  * to save version information to a file.
  1492.  */
  1493. void show_version(fp)
  1494. FILE *fp;
  1495. {
  1496.     /* If printed to a file, we prefix everything with
  1497.      * a hash mark to comment out the version information.
  1498.      */
  1499.     char prefix[6];        /* "#    " */
  1500.     char *p = prefix;
  1501.  
  1502.     prefix[0] = '#';
  1503.     prefix[1] = prefix[2] = prefix[3] = prefix[4] = ' ';
  1504.     prefix[5] = NUL;
  1505.  
  1506.     if (fp == stderr) {
  1507.     /* No hash mark - let p point to the trailing '\0' */
  1508.     p += sizeof(prefix) - 1;
  1509.     } else {
  1510. #ifdef GNUPLOT_BINDIR
  1511. # ifdef X11
  1512.     fprintf(fp, "#!%s/gnuplot -persist\n#\n", GNUPLOT_BINDIR);
  1513. #  else
  1514.     fprintf(fp, "#!%s/gnuplot\n#\n", GNUPLOT_BINDIR);
  1515. # endif                /* not X11 */
  1516. #endif /* GNUPLOT_BINDIR */
  1517.     }
  1518.     fprintf(fp, "%s\n\
  1519. %s\t%s\n\
  1520. %s\t%sversion %s\n\
  1521. %s\tpatchlevel %s\n\
  1522. %s\tlast modified %s\n\
  1523. %s\n\
  1524. %s\t%s\n\
  1525. %s\tThomas Williams, Colin Kelley and many others\n\
  1526. %s\n\
  1527. %s\tType `help` to access the on-line reference manual\n\
  1528. %s\tThe gnuplot FAQ is available from\n\
  1529. %s\t\t<%s>\n\
  1530. %s\n\
  1531. %s\tSend comments and requests for help to <%s>\n\
  1532. %s\tSend bugs, suggestions and mods to <%s>\n\
  1533. %s\n",
  1534.         p,            /* empty line */
  1535.         p, PROGRAM,
  1536.         p, OS, version,
  1537.         p, patchlevel,
  1538.         p, date,
  1539.         p,            /* empty line */
  1540.         p, gnuplot_copyright,
  1541.         p,            /* authors */
  1542.         p,            /* empty line */
  1543.         p,            /* Type help */
  1544.         p,            /* FAQ is at */
  1545.         p, faq_location,
  1546.         p,            /* empty line */
  1547.         p, help_email,
  1548.         p, bug_email,
  1549.         p);            /* empty line */
  1550. }
  1551.  
  1552. void show_version_long()
  1553. {
  1554.     char *helpfile = NULL;
  1555. #ifdef HAVE_SYS_UTSNAME_H
  1556.     struct utsname uts;
  1557.  
  1558.     /* something is fundamentally wrong if this fails ... */
  1559.     if (uname(&uts) > -1) {
  1560. # ifdef _AIX
  1561.     fprintf(stderr, "\nSystem: %s %s.%s", uts.sysname, uts.version, uts.release);
  1562. # elif defined (SCO)
  1563.     fprintf(stderr, "\nSystem: SCO %s", uts.release);
  1564. # else
  1565.     fprintf(stderr, "\nSystem: %s %s", uts.sysname, uts.release);
  1566. # endif
  1567.     } else {
  1568.     fprintf(stderr, "\n%s\n", OS);
  1569.     }
  1570.  
  1571. #else /* ! HAVE_SYS_UTSNAME_H */
  1572.  
  1573.     fprintf(stderr, "\n%s\n", OS);
  1574.  
  1575. #endif /* HAVE_SYS_UTSNAME_H */
  1576.  
  1577.     fputs("\nCompile options:\n", stderr);
  1578.  
  1579.     {
  1580.     /* The following code could be a lot simpler if
  1581.      * it wasn't for Borland's broken compiler ...
  1582.      */
  1583.     const char *rdline, *gnu_rdline, *libgd, *libpng, *linuxvga,
  1584.     *nocwdrc, *x11, *unixplot, *gnugraph;
  1585.  
  1586.     rdline =
  1587. #ifdef READLINE
  1588.         "+READLINE  "
  1589. #else
  1590.         "-READLINE  "
  1591. #endif
  1592.         ,gnu_rdline =
  1593. #ifdef GNU_READLINE
  1594.         "+GNU_READLINE  "
  1595. #else
  1596.         "-GNU_READLINE  "
  1597. #endif
  1598.         ,libgd =
  1599. #ifdef HAVE_LIBGD
  1600.         "+LIBGD  "
  1601. #else
  1602.         "-LIBGD  "
  1603. #endif
  1604.         ,libpng =
  1605. #ifdef HAVE_LIBPNG
  1606.         "+LIBPNG  "
  1607. #else
  1608.         "-LIBPNG  "
  1609. #endif
  1610.         ,linuxvga =
  1611. #ifdef LINUXVGA
  1612.         "+LINUXVGA  "
  1613. #else
  1614.         ""
  1615. #endif
  1616.         ,nocwdrc =
  1617. #ifdef NOCWDRC
  1618.         "+NOCWDRC  "
  1619. #else
  1620.         "-NOCWDRC  "
  1621. #endif
  1622.         ,x11 =
  1623.  
  1624. #ifdef X11
  1625.         "+X11  "
  1626. #else
  1627.         ""
  1628. #endif
  1629.         ,unixplot =
  1630. #ifdef UNIXPLOT
  1631.         "+UNIXPLOT  "
  1632. #else
  1633.         ""
  1634. #endif
  1635.         ,gnugraph =
  1636. #ifdef GNUGRAPH
  1637.         "+GNUGRAPH  "
  1638. #else
  1639.         ""
  1640. #endif
  1641.         ;
  1642.     fprintf(stderr, "%s%s%s%s%s%s%s%s%s\n\n", rdline, gnu_rdline,
  1643.           libgd, libpng, linuxvga, nocwdrc, x11, unixplot, gnugraph);
  1644.     }
  1645.  
  1646.     if ((helpfile = getenv("GNUHELP")) == NULL) {
  1647. #if defined(ATARI) || defined(MTOS)
  1648.     if ((helpfile = getenv("GNUPLOTPATH")) == NULL) {
  1649.         helpfile = HELPFILE;
  1650.     }
  1651. #else
  1652.     helpfile = HELPFILE;
  1653. #endif
  1654.     }
  1655.     fprintf(stderr, "HELPFILE     = \"%s\"\n\
  1656. FAQ location = <%s>\n\
  1657. CONTACT      = <%s>\n\
  1658. HELPMAIL     = <%s>\n", helpfile, faq_location, bug_email, help_email);
  1659. }
  1660.  
  1661. static void show_datatype(name, axis)
  1662. char *name;
  1663. int axis;
  1664. {
  1665.     fprintf(stderr, "\t%s is set to %s\n", name,
  1666.         datatype[axis] == TIME ? "time" : "numerical");
  1667. }
  1668.  
  1669. char *
  1670.  conv_text(s, t)
  1671. char *s, *t;
  1672. {
  1673.     /* convert unprintable characters as \okt, tab as \t, newline \n .. */
  1674.     char *r;
  1675.     r = s;
  1676.     while (*t != '\0') {
  1677.     switch (*t) {
  1678.     case '\t':
  1679.         *s++ = '\\';
  1680.         *s++ = 't';
  1681.         break;
  1682.     case '\n':
  1683.         *s++ = '\\';
  1684.         *s++ = 'n';
  1685.         break;
  1686. #ifndef OSK
  1687.     case '\r':
  1688.         *s++ = '\\';
  1689.         *s++ = 'r';
  1690.         break;
  1691. #endif
  1692.     case '"':
  1693.     case '\\':
  1694.         *s++ = '\\';
  1695.         *s++ = *t;
  1696.         break;
  1697.  
  1698.     default:{
  1699.         if ((*t & 0177) > 31 && (*t & 0177) < 127)
  1700.             *s++ = *t;
  1701.         else {
  1702.             *s++ = '\\';
  1703.             sprintf(s, "%o", *t);
  1704.             while (*s != '\0')
  1705.             s++;
  1706.         }
  1707.         }
  1708.     }
  1709.     t++;
  1710.     }
  1711.     *s = '\0';
  1712.     return (r);
  1713. }
  1714.  
  1715.  
  1716. static void show_position(pos)
  1717. struct position *pos;
  1718. {
  1719.     static char *msg[] =
  1720.     {"(first axes) ", "(second axes) ", "(graph units) ", "(screen units) "};
  1721.  
  1722.     assert(first_axes == 0 && second_axes == 1 && graph == 2 && screen == 3);
  1723.  
  1724.     fprintf(stderr, "(%s%g, %s%g, %s%g)",
  1725.         pos->scalex == first_axes ? "" : msg[pos->scalex], pos->x,
  1726.         pos->scaley == pos->scalex ? "" : msg[pos->scaley], pos->y,
  1727.         pos->scalez == pos->scaley ? "" : msg[pos->scalez], pos->z);
  1728.  
  1729. }
  1730.  
  1731. static void show_missing()
  1732. {
  1733.     if (missing_val == NULL)
  1734.     fputs("\tNo string is interpreted as missing data\n", stderr);
  1735.     else
  1736.     fprintf(stderr, "\t\"%s\" is interpreted as missing value\n", missing_val);
  1737. }
  1738.